home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / gtk-2.0 / demo / clipboard.c < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-25  |  9.8 KB  |  323 lines

  1. /* Clipboard
  2.  *
  3.  * GtkClipboard is used for clipboard handling. This demo shows how to
  4.  * copy and paste text to and from the clipboard. 
  5.  *
  6.  * It also shows how to transfer images via the clipboard or via 
  7.  * drag-and-drop, and how to make clipboard contents persist after
  8.  * the application exits. Clipboard persistence requires a clipboard
  9.  * manager to run.
  10.  */
  11.  
  12. #include <gtk/gtk.h>
  13. #include <string.h>
  14.  
  15. static GtkWidget *window = NULL;
  16.  
  17. void
  18. copy_button_clicked (GtkWidget *button,
  19.                      gpointer   user_data)
  20. {
  21.   GtkWidget *entry;
  22.   GtkClipboard *clipboard;
  23.  
  24.   entry = GTK_WIDGET (user_data);
  25.   
  26.   /* Get the clipboard object */
  27.   clipboard = gtk_widget_get_clipboard (entry,
  28.                                         GDK_SELECTION_CLIPBOARD);
  29.  
  30.   /* Set clipboard text */
  31.   gtk_clipboard_set_text (clipboard, gtk_entry_get_text (GTK_ENTRY (entry)), -1);
  32. }
  33.  
  34. void
  35. paste_received (GtkClipboard *clipboard,
  36.                 const gchar  *text,
  37.                 gpointer      user_data)
  38. {
  39.   GtkWidget *entry;
  40.  
  41.   entry = GTK_WIDGET (user_data);
  42.   
  43.   /* Set the entry text */
  44.   if(text)
  45.     gtk_entry_set_text (GTK_ENTRY (entry), text);
  46. }
  47.  
  48. void
  49. paste_button_clicked (GtkWidget *button,
  50.                      gpointer   user_data)
  51. {
  52.   GtkWidget *entry;
  53.   GtkClipboard *clipboard;
  54.  
  55.   entry = GTK_WIDGET (user_data);
  56.   
  57.   /* Get the clipboard object */
  58.   clipboard = gtk_widget_get_clipboard (entry,
  59.                                         GDK_SELECTION_CLIPBOARD);
  60.  
  61.   /* Request the contents of the clipboard, contents_received will be
  62.      called when we do get the contents.
  63.    */
  64.   gtk_clipboard_request_text (clipboard,
  65.                               paste_received, entry);
  66. }
  67.  
  68. static GdkPixbuf *
  69. get_image_pixbuf (GtkImage *image)
  70. {
  71.   gchar *stock_id;
  72.   GtkIconSize size;
  73.  
  74.   switch (gtk_image_get_storage_type (image))
  75.     {
  76.     case GTK_IMAGE_PIXBUF:
  77.       return g_object_ref (gtk_image_get_pixbuf (image));
  78.     case GTK_IMAGE_STOCK:
  79.       gtk_image_get_stock (image, &stock_id, &size);
  80.       return gtk_widget_render_icon (GTK_WIDGET (image),
  81.                                      stock_id, size, NULL);
  82.     default:
  83.       g_warning ("Image storage type %d not handled", 
  84.                  gtk_image_get_storage_type (image));
  85.       return NULL;
  86.     }
  87. }
  88.  
  89. static void
  90. drag_begin (GtkWidget      *widget,
  91.             GdkDragContext *context,
  92.             gpointer        data)
  93. {
  94.   GdkPixbuf *pixbuf;
  95.  
  96.   pixbuf = get_image_pixbuf (GTK_IMAGE (data));
  97.   gtk_drag_set_icon_pixbuf (context, pixbuf, -2, -2);
  98.   g_object_unref (pixbuf);
  99. }
  100.  
  101. void  
  102. drag_data_get  (GtkWidget        *widget,
  103.                 GdkDragContext   *context,
  104.                 GtkSelectionData *selection_data,
  105.                 guint             info,
  106.                 guint             time,
  107.                 gpointer          data)
  108. {
  109.   GdkPixbuf *pixbuf;
  110.  
  111.   pixbuf = get_image_pixbuf (GTK_IMAGE (data));
  112.   gtk_selection_data_set_pixbuf (selection_data, pixbuf);
  113.   g_object_unref (pixbuf);
  114. }
  115.  
  116. static void
  117. drag_data_received (GtkWidget        *widget,
  118.                     GdkDragContext   *context,
  119.                     gint              x,
  120.                     gint              y,
  121.                     GtkSelectionData *selection_data,
  122.                     guint             info,
  123.                     guint32           time,
  124.                     gpointer          data)
  125. {
  126.   GdkPixbuf *pixbuf;
  127.  
  128.   if (selection_data->length > 0)
  129.     {
  130.       pixbuf = gtk_selection_data_get_pixbuf (selection_data);
  131.       gtk_image_set_from_pixbuf (GTK_IMAGE (data), pixbuf);
  132.       g_object_unref (pixbuf);
  133.     }
  134. }
  135.  
  136. static void
  137. copy_image (GtkMenuItem *item,
  138.             gpointer     data)
  139. {
  140.   GtkClipboard *clipboard;
  141.   GdkPixbuf *pixbuf;
  142.  
  143.   clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
  144.   pixbuf = get_image_pixbuf (GTK_IMAGE (data));
  145.  
  146.   gtk_clipboard_set_image (clipboard, pixbuf);
  147.   g_object_unref (pixbuf);
  148. }
  149.  
  150. static void
  151. paste_image (GtkMenuItem *item,
  152.              gpointer     data)
  153. {
  154.   GtkClipboard *clipboard;
  155.   GdkPixbuf *pixbuf;
  156.  
  157.   clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
  158.   pixbuf = gtk_clipboard_wait_for_image (clipboard);
  159.  
  160.   if (pixbuf)
  161.     {
  162.       gtk_image_set_from_pixbuf (GTK_IMAGE (data), pixbuf);
  163.       g_object_unref (pixbuf);
  164.     }
  165. }
  166.  
  167. static gboolean
  168. button_press (GtkWidget      *widget,
  169.               GdkEventButton *button,
  170.               gpointer        data)
  171. {
  172.   GtkWidget *menu;
  173.   GtkWidget *item;
  174.   
  175.   if (button->button != 3)
  176.     return FALSE;
  177.  
  178.   menu = gtk_menu_new ();
  179.   
  180.   item = gtk_image_menu_item_new_from_stock (GTK_STOCK_COPY, NULL);
  181.   g_signal_connect (item, "activate", G_CALLBACK (copy_image), data);
  182.   gtk_widget_show (item);
  183.   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
  184.  
  185.   item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PASTE, NULL);
  186.   g_signal_connect (item, "activate", G_CALLBACK (paste_image), data);
  187.   gtk_widget_show (item);
  188.   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
  189.  
  190.   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 3, button->time);
  191.   return TRUE;
  192. }
  193.  
  194. GtkWidget *
  195. do_clipboard (GtkWidget *do_widget)
  196. {
  197.   if (!window)
  198.     {
  199.       GtkWidget *vbox, *hbox;
  200.       GtkWidget *label;
  201.       GtkWidget *entry, *button;
  202.       GtkWidget *ebox, *image;
  203.       GtkClipboard *clipboard;
  204.       
  205.       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  206.       g_signal_connect (window, "destroy",
  207.                         G_CALLBACK (gtk_widget_destroyed), &window);
  208.  
  209.       vbox = gtk_vbox_new (FALSE, 0);
  210.       gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
  211.       
  212.       gtk_container_add (GTK_CONTAINER (window), vbox);
  213.  
  214.       label = gtk_label_new ("\"Copy\" will copy the text\nin the entry to the clipboard");
  215.       
  216.       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  217.  
  218.       hbox = gtk_hbox_new (FALSE, 4);
  219.       gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
  220.       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  221.  
  222.       /* Create the first entry */
  223.       entry = gtk_entry_new ();
  224.       gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
  225.       
  226.       /* Create the button */
  227.       button = gtk_button_new_from_stock (GTK_STOCK_COPY);
  228.       gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
  229.       g_signal_connect (button, "clicked",
  230.                         G_CALLBACK (copy_button_clicked), entry);
  231.  
  232.       label = gtk_label_new ("\"Paste\" will paste the text from the clipboard to the entry");
  233.       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  234.  
  235.       hbox = gtk_hbox_new (FALSE, 4);
  236.       gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
  237.       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  238.  
  239.       /* Create the second entry */
  240.       entry = gtk_entry_new ();
  241.       gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
  242.       
  243.       /* Create the button */
  244.       button = gtk_button_new_from_stock (GTK_STOCK_PASTE);
  245.       gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
  246.       g_signal_connect (button, "clicked",
  247.                         G_CALLBACK (paste_button_clicked), entry);
  248.       
  249.       label = gtk_label_new ("Images can be transferred via the clipboard, too");
  250.       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  251.  
  252.       hbox = gtk_hbox_new (FALSE, 4);
  253.       gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
  254.       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  255.  
  256.       /* Create the first image */
  257.       image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, 
  258.                                         GTK_ICON_SIZE_BUTTON);
  259.       ebox = gtk_event_box_new ();
  260.       gtk_container_add (GTK_CONTAINER (ebox), image);
  261.       gtk_container_add (GTK_CONTAINER (hbox), ebox);
  262.  
  263.       /* make ebox a drag source */
  264.       gtk_drag_source_set (ebox, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY);
  265.       gtk_drag_source_add_image_targets (ebox);
  266.       g_signal_connect (ebox, "drag_begin", 
  267.                         G_CALLBACK (drag_begin), image);
  268.       g_signal_connect (ebox, "drag_data_get", 
  269.                         G_CALLBACK (drag_data_get), image);
  270.       
  271.       /* accept drops on ebox */
  272.       gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL, 
  273.                          NULL, 0, GDK_ACTION_COPY);
  274.       gtk_drag_dest_add_image_targets (ebox);
  275.       g_signal_connect (ebox, "drag_data_received", 
  276.                         G_CALLBACK (drag_data_received), image);
  277.       
  278.       /* context menu on ebox */
  279.       g_signal_connect (ebox, "button_press_event", 
  280.                         G_CALLBACK (button_press), image);
  281.  
  282.       /* Create the second image */
  283.       image = gtk_image_new_from_stock (GTK_STOCK_STOP, 
  284.                                         GTK_ICON_SIZE_BUTTON);
  285.       ebox = gtk_event_box_new ();
  286.       gtk_container_add (GTK_CONTAINER (ebox), image);
  287.       gtk_container_add (GTK_CONTAINER (hbox), ebox);
  288.  
  289.       /* make ebox a drag source */
  290.       gtk_drag_source_set (ebox, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY);
  291.       gtk_drag_source_add_image_targets (ebox);
  292.       g_signal_connect (ebox, "drag_begin", 
  293.                         G_CALLBACK (drag_begin), image);
  294.       g_signal_connect (ebox, "drag_data_get", 
  295.                         G_CALLBACK (drag_data_get), image);
  296.       
  297.       /* accept drops on ebox */
  298.       gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL, 
  299.                          NULL, 0, GDK_ACTION_COPY);
  300.       gtk_drag_dest_add_image_targets (ebox);
  301.       g_signal_connect (ebox, "drag_data_received", 
  302.                         G_CALLBACK (drag_data_received), image);
  303.       
  304.       /* context menu on ebox */
  305.       g_signal_connect (ebox, "button_press_event", 
  306.                         G_CALLBACK (button_press), image);
  307.       
  308.       /* tell the clipboard manager to make the data persistent */
  309.       clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
  310.       gtk_clipboard_set_can_store (clipboard, NULL, 0);
  311.     }
  312.  
  313.   if (!GTK_WIDGET_VISIBLE (window))
  314.     gtk_widget_show_all (window);
  315.   else
  316.     {
  317.       gtk_widget_destroy (window);
  318.       window = NULL;
  319.     }
  320.  
  321.   return window;
  322. }
  323.